home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / MNetsrc.hqx / Mac TCP_IP Source v.33 / session.c < prev    next >
Text File  |  1989-03-24  |  9KB  |  481 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "netuser.h"
  7. #include "timer.h"
  8. #include "tcp.h"
  9. #include "ax25.h"
  10. #include "lapb.h"
  11. #ifdef MAC
  12. #include "MacBinary.h"
  13. #endif
  14. #include "ftp.h"
  15. #include "telnet.h"
  16. #ifdef _FINGER
  17. #include "finger.h"
  18. #endif
  19. #ifdef NETROM
  20. #include "netrom.h"
  21. #include "nr4.h"
  22. #endif
  23. #include "session.h"
  24. #include "cmdparse.h"
  25. #ifdef MAC
  26. #include "mac_files.h"
  27. #endif
  28.  
  29. struct session *sessions;
  30. struct session *current;
  31. char notval[] = "Not a valid control block\n";
  32. char badsess[] = "Invalid session\n";
  33.  
  34. /* Convert a character string containing a decimal session index number 
  35.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  36.  * If the index is out of range or unused, return NULLSESSION.
  37.  */
  38. static struct session *
  39. sessptr(cp)
  40. char *cp;
  41. {
  42.     register struct session *s;
  43.     unsigned int i;
  44.  
  45.     if(cp == NULLCHAR){
  46.         s = current;
  47.     } else {
  48.         if((i = atoi(cp)) >= nsessions)
  49.             return NULLSESSION;
  50.         s = &sessions[i];
  51.     }
  52.     if(s == NULLSESSION || s->type == FREE)
  53.         return NULLSESSION;
  54.  
  55.     return s;
  56. }
  57.  
  58. /* Select and display sessions */
  59. dosession(argc,argv)
  60. int argc;
  61. char *argv[];
  62. {
  63.     struct session *s;
  64.     extern char *tcpstates[];
  65.     char *psocket();
  66.     extern char *ax25states[];
  67.     char *tcp_port();
  68.  
  69.     if(argc > 1){
  70.         if((current = sessptr(argv[1])) != NULLSESSION)
  71.             go();
  72.         return 0;
  73.     }
  74.     printf(" #       &CB Type   Rcv-Q  State        Remote socket\n");
  75.     for(s=sessions; s < &sessions[nsessions];s++){
  76.         switch(s->type){
  77.         case TELNET:
  78.             printf("%c%-3d%8lx Telnet  %4d  %-13s%-s:%s",
  79.              (current == s)? '*':' ',
  80.              (int)(s - sessions),
  81.              (long)s->cb.telnet->tcb,
  82.              s->cb.telnet->tcb->rcvcnt,
  83.              tcpstates[s->cb.telnet->tcb->state],
  84.              s->name,
  85.              tcp_port(s->cb.telnet->tcb->conn.remote.port));
  86.             break;
  87.         case FTP:
  88.             printf("%c%-3d%8lx FTP     %4d  %-13s%-s:%s",
  89.              (current == s)? '*':' ',
  90.              (int)(s - sessions),
  91.              (long)s->cb.ftp->control,
  92.              s->cb.ftp->control->rcvcnt,
  93.              tcpstates[s->cb.ftp->control->state],
  94.              s->name,
  95.              tcp_port(s->cb.ftp->control->conn.remote.port));
  96.             break;
  97. #ifdef    AX25
  98.         case AX25TNC:
  99.             printf("%c%-3d%8lx AX25    %4d  %-13s%-s",
  100.              (current == s)? '*':' ',
  101.              (int)(s - sessions),
  102.              (long)s->cb.ax25_cb,
  103.             len_mbuf(s->cb.ax25_cb->rxq),
  104.              ax25states[s->cb.ax25_cb->state],
  105.              s->name);
  106.             break;
  107. #endif
  108. #ifdef    _FINGER
  109.         case FINGER:
  110.             printf("%c%-3d%8lx Finger  %4d  %-13s%-s",
  111.              (current == s)? '*':' ',
  112.              (int)(s - sessions),
  113.              (long)s->cb.finger->tcb,
  114.              s->cb.finger->tcb->rcvcnt,
  115.              tcpstates[s->cb.finger->tcb->state],
  116.              s->name, s->cb.finger->tcb->conn.remote.port);
  117.             break;
  118. #endif
  119. #ifdef NETROM
  120.         case NRSESSION:
  121.             printf("%c%-3d%8lx NET/ROM %4d  %-13s%-s",
  122.              (current == s)? '*':' ',
  123.              (int)(s - sessions),
  124.              (long)s->cb.nr4_cb,
  125.             len_mbuf(s->cb.nr4_cb->rxq),
  126.              Nr4states[s->cb.nr4_cb->state],
  127.              s->name);
  128.             break;
  129. #endif
  130.         default:
  131.             continue;
  132.         }
  133.         if(s->rfile != NULLCHAR || s->ufile != NULLCHAR)
  134.             printf("\t");
  135.         if(s->rfile != NULLCHAR)
  136.             printf("Record: %s ",s->rfile);
  137.         if(s->ufile != NULLCHAR)
  138.             printf("Upload: %s",s->ufile);
  139.         printf("\n");
  140.     }
  141.     return 0;
  142. }
  143. /* Enter conversational mode with current session */
  144. int
  145. go()
  146. {
  147.     void rcv_char(),ftpccr(),ax_rx(),fingcli_rcv() ;
  148.  
  149.     if(current == NULLSESSION || current->type == FREE)
  150.         return 0;
  151.     mode = CONV_MODE;
  152.     switch(current->type){
  153.     case TELNET:
  154.         if(current->cb.telnet->remote[TN_ECHO])
  155.             raw();    /* Re-establish raw mode if it was set */
  156.         rcv_char(current->cb.telnet->tcb,0); /* Get any pending input */
  157.         break;
  158.     case FTP:
  159.         ftpccr(current->cb.ftp->control,0);
  160.         break;
  161. #ifdef    AX25
  162.     case AX25TNC:
  163.         ax_rx(current->cb.ax25_cb,0);
  164.         break;
  165. #endif
  166. #ifdef _FINGER
  167.     case FINGER:
  168.         fingcli_rcv(current->cb.finger->tcb,0) ;
  169.         break ;
  170. #endif
  171. #ifdef    NETROM
  172.     case NRSESSION:
  173.         nr4_rx(current->cb.nr4_cb,0) ;
  174.         break ;
  175. #endif
  176.     }
  177.     return 0;
  178. }
  179. doclose(argc,argv)
  180. int argc;
  181. char *argv[];
  182. {
  183.     struct session *s;
  184.  
  185.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  186.         printf(badsess);
  187.         return -1;
  188.     }
  189.     switch(s->type){
  190.     case TELNET:
  191.         close_tcp(s->cb.telnet->tcb);
  192.         break;
  193.     case FTP:
  194.         close_tcp(s->cb.ftp->control);
  195.         break;
  196. #ifdef    AX25
  197.     case AX25TNC:
  198.         disc_ax25(s->cb.ax25_cb);
  199.         break;
  200. #endif
  201. #ifdef _FINGER
  202.     case FINGER:
  203.         close_tcp(s->cb.finger->tcb);
  204.         break;
  205. #endif
  206. #ifdef NETROM
  207.     case NRSESSION:
  208.         disc_nr4(s->cb.nr4_cb) ;
  209.         break ;
  210. #endif
  211.     }
  212.     return 0;
  213. }
  214. doreset(argc,argv)
  215. int argc;
  216. char *argv[];
  217. {
  218.     long htol();
  219.     struct session *s;
  220.  
  221.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  222.         printf(badsess);
  223.         return -1;
  224.     }
  225.     switch(s->type){
  226.     case TELNET:
  227.         reset_tcp(s->cb.telnet->tcb);
  228.         break;
  229.     case FTP:
  230.         if(s->cb.ftp->data != NULLTCB){
  231.             reset_tcp(s->cb.ftp->data);
  232.             s->cb.ftp->data = NULLTCB;
  233.         }
  234.         reset_tcp(s->cb.ftp->control);
  235.         break;
  236. #ifdef    AX25
  237.     case AX25TNC:
  238.         reset_ax25(s->cb.ax25_cb);
  239.         break;
  240. #endif
  241. #ifdef _FINGER
  242.     case FINGER:
  243.         reset_tcp(s->cb.finger->tcb);
  244.         break;
  245. #endif
  246. #ifdef NETROM
  247.     case NRSESSION:
  248.         reset_nr4(s->cb.nr4_cb) ;
  249.         break ;
  250. #endif
  251.     }
  252.     return 0;
  253. }
  254. int
  255. dokick(argc,argv)
  256. int argc;
  257. char *argv[];
  258. {
  259.     long htol();
  260.     void tcp_timeout();
  261.     struct session *s;
  262.  
  263.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  264.         printf(badsess);
  265.         return -1;
  266.     }
  267.     switch(s->type){
  268.     case TELNET:
  269.         if(kick_tcp(s->cb.telnet->tcb) == -1){
  270.             printf(notval);
  271.             return 1;
  272.         }
  273.         break;
  274.     case FTP:
  275.         if(kick_tcp(s->cb.ftp->control) == -1){
  276.  
  277.             printf(notval);
  278.             return 1;
  279.         }
  280.         if(s->cb.ftp->data != NULLTCB)
  281.             kick_tcp(s->cb.ftp->data);
  282.         break;
  283. #ifdef    AX25
  284.     case AX25TNC:
  285.         if(kick_ax25(s->cb.ax25_cb) == -1){
  286.             printf(notval);
  287.             return 1;
  288.         }
  289.         return 1;
  290. #endif
  291. #ifdef _FINGER
  292.     case FINGER:
  293.         if(kick_tcp(s->cb.finger->tcb) == -1){
  294.             printf(notval);
  295.             return 1;
  296.         }
  297.         break;
  298. #endif
  299. #ifdef NETROM
  300.     case NRSESSION:
  301.         if(kick_nr4(s->cb.nr4_cb) == -1) {
  302.             printf(notval) ;
  303.             return 1 ;
  304.         }
  305.         break ;
  306. #endif
  307.     }
  308.     return 0;
  309. }
  310. struct session *
  311. newsession()
  312. {
  313.     register int i;
  314.  
  315.     for(i=0;i<nsessions;i++)
  316.         if(sessions[i].type == FREE)
  317.             return &sessions[i];
  318.     return NULLSESSION;
  319. }
  320. freesession(s)
  321. struct session *s;
  322. {
  323.     if(s == NULLSESSION)
  324.         return;
  325.     if(s->record != NULLFILE){
  326.         fclose(s->record);
  327.         s->record = NULLFILE;
  328.     }
  329.     if(s->rfile != NULLCHAR){
  330.         free(s->rfile);
  331.         s->rfile = NULLCHAR;
  332.     }
  333.     if(s->upload != NULLFILE){
  334.         fclose(s->upload);
  335.         s->upload = NULLFILE;
  336.     }
  337.     if(s->ufile != NULLCHAR){
  338.         free(s->ufile);
  339.         s->ufile = NULLCHAR;
  340.     }
  341.     if(s->name != NULLCHAR){
  342.         free(s->name);
  343.         s->name = NULLCHAR;
  344.     }
  345.     s->type = FREE;
  346. }
  347. /* Control session recording */
  348. dorecord(argc,argv)
  349. int argc;
  350. char *argv[];
  351. {
  352. #ifdef MAC
  353.     char *pathname();
  354. #endif
  355.  
  356.     if(current == NULLSESSION){
  357.         printf("No current session\n");
  358.         return 1;
  359.     }
  360.     if(argc > 1){
  361.         if(current->rfile != NULLCHAR){
  362.             fclose(current->record);
  363.             free(current->rfile);
  364.             current->record = NULLFILE;
  365.             current->rfile = NULLCHAR;
  366.         }
  367.         /* Open new record file, unless file name is "off", which means
  368.          * disable recording
  369.          */
  370. #ifdef MAC
  371.         if (strcmp(argv[1],"off") != 0) {
  372.             current->rfile = pathname(applroot,argv[1]);
  373.             if ((current->record = fopen(current->rfile,"a")) == NULLFILE) {
  374.                 (void) free(current->rfile);
  375.                 current->rfile = NULLCHAR;
  376.             }
  377.         }
  378. #else
  379.         if(strcmp(argv[1],"off") != 0
  380.          && (current->record = fopen(argv[1],"a")) != NULLFILE){
  381.             current->rfile = malloc((unsigned)strlen(argv[1])+1);
  382.             strcpy(current->rfile,argv[1]);
  383.         }
  384. #endif
  385.     }
  386.     if(current->rfile != NULLCHAR)
  387.         printf("Recording into '%s'.\n",current->rfile);
  388.     else
  389.         printf("Recording off.\n");
  390.     return 0;
  391. }
  392. /* Control file transmission */
  393. doupload(argc,argv)
  394. int argc;
  395. char *argv[];
  396. {
  397.     struct tcb *tcb;
  398.     struct ax25_cb *axp;
  399. #ifdef NETROM
  400.     struct nr4cb *cb ;
  401. #endif
  402. #ifdef MAC
  403.     char sessname[256],*pathname();
  404.     char *ptr;
  405. #endif
  406.  
  407.     if(current == NULLSESSION){
  408.         printf("No current session\n");
  409.         return 1;
  410.     }
  411.     if(argc > 1){
  412.         switch(current->type){
  413.         case TELNET:
  414.             tcb = current->cb.telnet->tcb;
  415.             break;
  416. #ifdef    AX25
  417.         case AX25TNC:
  418.             axp = current->cb.ax25_cb;
  419.             break;
  420. #endif
  421. #ifdef NETROM
  422.         case NRSESSION:
  423.             cb = current->cb.nr4_cb ;
  424.             break ;
  425. #endif
  426.         case FTP:
  427.             printf("Uploading on FTP control channel not supported\n");
  428.             return 1;
  429.         }
  430.         if(strcmp(argv[1],"stop") == 0 && current->upload != NULLFILE){
  431.             /* Abort upload */
  432.             fclose(current->upload);
  433.             current->upload = NULLFILE;
  434.             if(current->ufile != NULLCHAR){
  435.                 free(current->ufile);
  436.                 current->ufile = NULLCHAR;
  437.             }
  438.         }
  439.         /* Open upload file */
  440. #ifdef MAC
  441.         ptr = pathname(applroot,argv[1]);
  442.         strcpy(sessname,ptr);
  443.         (void)free(ptr);
  444.         if((current->upload = fopen(sessname,"r")) == NULLFILE){
  445. #else
  446.         if((current->upload = fopen(argv[1],"r")) == NULLFILE){
  447. #endif
  448.             printf("Can't read %s\n",argv[1]);
  449.             return 1;
  450.         }
  451. #ifdef MAC
  452.         current->ufile = malloc((unsigned)strlen(sessname)+1);
  453. #else
  454.         current->ufile = malloc((unsigned)strlen(argv[1])+1);
  455. #endif
  456.         strcpy(current->ufile,argv[1]);
  457.         /* All set, kick transmit upcall to get things rolling */
  458.         switch(current->type){
  459. #ifdef    AX25
  460.         case AX25TNC:
  461.             (*axp->t_upcall)(axp,axp->paclen * axp->maxframe);
  462.             break;
  463. #endif
  464. #ifdef NETROM
  465.         case NRSESSION:
  466.             (*cb->t_upcall)(cb, NR4MAXINFO) ;
  467.             break ;
  468. #endif
  469.         case TELNET:
  470.             (*tcb->t_upcall)(tcb,tcb->snd.wnd - tcb->sndcnt);
  471.             break;
  472.         }
  473.     }
  474.     if(current->ufile != NULLCHAR)
  475.         printf("Uploading %s\n",current->ufile);
  476.     else
  477.         printf("Uploading off\n");
  478.     return 0;
  479. }
  480.  
  481.